package tools

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"strings"
	"time"
)

// WebSearch 实现了基于 Google Serpapi 的网络搜索工具
// 该工具允许 ReAct 智能体进行实时网络搜索获取信息
type WebSearch struct {
	client  *http.Client
	timeout time.Duration
	apiKey  string
	baseURL string
}

// SerpApiResponse Serpapi API 响应结构
type SerpApiResponse struct {
	SearchParameters  SearchParameters  `json:"search_parameters"`
	SearchInformation SearchInformation `json:"search_information"`
	OrganicResults    []OrganicResult   `json:"organic_results"`
	AnswerBox         *AnswerBox        `json:"answer_box,omitempty"`
	KnowledgeGraph    *KnowledgeGraph   `json:"knowledge_graph,omitempty"`
	ErrorMessage      string            `json:"error,omitempty"`
}

// SearchParameters 搜索参数
type SearchParameters struct {
	Engine string `json:"engine"`
	Q      string `json:"q"`
	Gl     string `json:"gl"`
	Hl     string `json:"hl"`
}

// SearchInformation 搜索信息
type SearchInformation struct {
	TotalResults        int64   `json:"total_results"`
	TimeTaken           float64 `json:"time_taken_displayed"`
	OrganicResultsState string  `json:"organic_results_state"`
	QueryDisplayed      string  `json:"query_displayed"`
}

// OrganicResult 有机搜索结果
type OrganicResult struct {
	Position int    `json:"position"`
	Title    string `json:"title"`
	Link     string `json:"link"`
	Snippet  string `json:"snippet"`
	Source   string `json:"source,omitempty"`
}

// AnswerBox 答案框
type AnswerBox struct {
	Type    string `json:"type"`
	Title   string `json:"title"`
	Answer  string `json:"answer"`
	Link    string `json:"link"`
	Snippet string `json:"snippet"`
}

// KnowledgeGraph 知识图谱
type KnowledgeGraph struct {
	Title       string `json:"title"`
	Type        string `json:"type"`
	Description string `json:"description"`
	Source      struct {
		Name string `json:"name"`
		Link string `json:"link"`
	} `json:"source"`
}

// SearchResult 格式化的搜索结果
type SearchResult struct {
	Query     string       `json:"query"`
	Items     []SearchItem `json:"items"`
	Summary   string       `json:"summary"`
	Total     int64        `json:"total_results"`
	TimeTaken float64      `json:"time_taken"`
}

// SearchItem 搜索项
type SearchItem struct {
	Position int    `json:"position"`
	Title    string `json:"title"`
	Snippet  string `json:"snippet"`
	URL      string `json:"url"`
	Source   string `json:"source"`
}

// NewWebSearch 创建新的网络搜索实例
func NewWebSearch() *WebSearch {
	// 从环境变量获取 API 密钥
	apiKey := os.Getenv("SERPAPI_KEY")

	return &WebSearch{
		client: &http.Client{
			Timeout: 30 * time.Second,
		},
		timeout: 30 * time.Second,
		apiKey:  apiKey,
		baseURL: "https://serpapi.com/search",
	}
}

// NewWebSearchWithKey 使用指定的 API 密钥创建网络搜索实例
func NewWebSearchWithKey(serpApiKey string) *WebSearch {
	// 优先使用传入的密钥，如果没有则使用环境变量
	apiKey := serpApiKey
	if apiKey == "" {
		apiKey = os.Getenv("SERPAPI_KEY")
	}

	return &WebSearch{
		client: &http.Client{
			Timeout: 30 * time.Second,
		},
		timeout: 30 * time.Second,
		apiKey:  apiKey,
		baseURL: "https://serpapi.com/search",
	}
}

// Name 返回工具名称
func (ws *WebSearch) Name() string {
	return "web_search"
}

// Description 返回工具描述
func (ws *WebSearch) Description() string {
	return `使用Google搜索引擎进行实时网络搜索，获取最新的信息和数据。基于Serpapi提供高质量的搜索结果。

**参数说明：**
- query (string, 必需): 搜索查询词，支持中英文搜索
  - 支持关键词搜索: "人工智能最新发展"
  - 支持问题搜索: "什么是ChatGPT"  
  - 支持具体查询: "2024年奥运会金牌榜"
  - 支持技术查询: "Go语言最佳实践"
- limit (int, 可选): 返回结果数量，默认为10，最大20

**使用示例：**
` + "```json" + `
{
  "type": "action",
  "action": "web_search", 
  "parameters": {
    "query": "人工智能最新发展趋势2024"
  }
}
` + "```" + `

` + "```json" + `
{
  "type": "action",
  "action": "web_search",
  "parameters": {
    "query": "Go语言框架对比",
    "limit": 5
  }
}
` + "```" + `

**返回结果包含：**
- 搜索结果列表（标题、摘要、链接）
- 总结果数量和搜索用时
- 如有答案框或知识图谱信息会优先展示`
}

// Execute 执行搜索
func (ws *WebSearch) Execute(args map[string]interface{}) (string, error) {
	// 检查 API 密钥
	if ws.apiKey == "" {
		return "", fmt.Errorf("Serpapi密钥未设置，请在配置文件中设置 serpapi_key 或环境变量 SERPAPI_KEY")
	}

	// 提取搜索查询
	query, ok := args["query"].(string)
	if !ok || strings.TrimSpace(query) == "" {
		return "", fmt.Errorf("搜索查询不能为空")
	}

	// 提取结果数量限制
	limit := 10 // 默认值
	if l, ok := args["limit"]; ok {
		if limitInt, ok := l.(float64); ok {
			limit = int(limitInt)
		} else if limitInt, ok := l.(int); ok {
			limit = limitInt
		}
	}

	// 限制结果数量范围
	if limit < 1 {
		limit = 1
	}
	if limit > 20 {
		limit = 20
	}

	// 执行搜索
	results, err := ws.searchGoogle(query, limit)
	if err != nil {
		return "", fmt.Errorf("搜索失败: %v", err)
	}

	// 格式化返回结果
	return ws.formatResults(results), nil
}

// searchGoogle 使用 Serpapi 进行 Google 搜索
func (ws *WebSearch) searchGoogle(query string, limit int) (*SerpApiResponse, error) {
	// 构建请求 URL
	params := url.Values{
		"api_key": {ws.apiKey},
		"engine":  {"google"},
		"q":       {query},
		"num":     {fmt.Sprintf("%d", limit)},
		"hl":      {"zh-cn"}, // 中文界面
		"gl":      {"cn"},    // 中国地区
	}

	searchURL := ws.baseURL + "?" + params.Encode()

	// 发起请求
	resp, err := ws.client.Get(searchURL)
	if err != nil {
		return nil, fmt.Errorf("请求失败: %v", err)
	}
	defer resp.Body.Close()

	// 读取响应体
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("读取响应失败: %v", err)
	}

	// 检查 HTTP 状态
	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("HTTP错误 %d: %s", resp.StatusCode, string(body))
	}

	// 解析 JSON 响应
	var result SerpApiResponse
	if err := json.Unmarshal(body, &result); err != nil {
		return nil, fmt.Errorf("解析响应失败: %v", err)
	}

	// 检查是否有错误信息
	if result.ErrorMessage != "" {
		return nil, fmt.Errorf("Serpapi错误: %s", result.ErrorMessage)
	}

	return &result, nil
}

// formatResults 格式化搜索结果为可读文本
func (ws *WebSearch) formatResults(response *SerpApiResponse) string {
	var result strings.Builder

	// 搜索信息头部
	result.WriteString(fmt.Sprintf("🔍 Google搜索结果 - 查询: \"%s\"\n", response.SearchParameters.Q))
	result.WriteString(fmt.Sprintf("📊 找到约 %s 个结果，用时 %.2f 秒\n\n",
		formatNumber(response.SearchInformation.TotalResults),
		response.SearchInformation.TimeTaken))

	// 答案框（如果有）
	if response.AnswerBox != nil {
		result.WriteString("💡 直接答案:\n")
		result.WriteString(fmt.Sprintf("**%s**\n", response.AnswerBox.Title))
		if response.AnswerBox.Answer != "" {
			result.WriteString(fmt.Sprintf("答案: %s\n", response.AnswerBox.Answer))
		}
		if response.AnswerBox.Snippet != "" {
			result.WriteString(fmt.Sprintf("详情: %s\n", response.AnswerBox.Snippet))
		}
		if response.AnswerBox.Link != "" {
			result.WriteString(fmt.Sprintf("来源: %s\n", response.AnswerBox.Link))
		}
		result.WriteString("\n")
	}

	// 知识图谱（如果有）
	if response.KnowledgeGraph != nil {
		result.WriteString("📖 知识图谱:\n")
		result.WriteString(fmt.Sprintf("**%s**\n", response.KnowledgeGraph.Title))
		if response.KnowledgeGraph.Description != "" {
			result.WriteString(fmt.Sprintf("%s\n", response.KnowledgeGraph.Description))
		}
		if response.KnowledgeGraph.Source.Name != "" {
			result.WriteString(fmt.Sprintf("来源: %s - %s\n",
				response.KnowledgeGraph.Source.Name,
				response.KnowledgeGraph.Source.Link))
		}
		result.WriteString("\n")
	}

	// 有机搜索结果
	if len(response.OrganicResults) > 0 {
		result.WriteString("🌐 搜索结果:\n\n")
		for i, item := range response.OrganicResults {
			result.WriteString(fmt.Sprintf("%d. **%s**\n", i+1, item.Title))
			if item.Snippet != "" {
				result.WriteString(fmt.Sprintf("   %s\n", item.Snippet))
			}
			result.WriteString(fmt.Sprintf("   🔗 %s\n\n", item.Link))
		}
	}

	// 搜索建议
	result.WriteString("💡 提示: 如需更多信息，可以点击相关链接查看详细内容。\n")

	return result.String()
}

// formatNumber 格式化大数字显示
func formatNumber(n int64) string {
	if n >= 1000000000 {
		return fmt.Sprintf("%.1f亿", float64(n)/1000000000)
	} else if n >= 100000000 {
		return fmt.Sprintf("%.0f千万", float64(n)/10000000)
	} else if n >= 10000000 {
		return fmt.Sprintf("%.0f百万", float64(n)/1000000)
	} else if n >= 1000000 {
		return fmt.Sprintf("%.1f百万", float64(n)/1000000)
	} else if n >= 100000 {
		return fmt.Sprintf("%.0f万", float64(n)/10000)
	} else if n >= 10000 {
		return fmt.Sprintf("%.1f万", float64(n)/10000)
	}
	return fmt.Sprintf("%d", n)
}
